package com.cc.pokergame.model;

import android.util.Log;
import android.view.View;
import android.widget.ImageView;

import java.util.ArrayList;

/**
 * 玩家管理器
 */
public class PlayerManager {
    // 玩家列表
    private ArrayList<Player> players = new ArrayList<>();
    private OnActivePlayerChangeListener mListener = null;
    private OnPkFinishedListener pkFinishedListener = null;

    // 当前玩家索引值
    private int playerIndex = -1;

    // 记录上一次玩家对象
    private Player lastActivityPlayer = null;

    /**
     * 添加玩家
     *
     * @param avatarId 玩家头像
     * @param name     玩家名称
     * @param money    玩家金额
     * @param view     玩家视图
     */
    public void addPlayer(int avatarId, String name, int money, View view, CardModel pokerView) {
        // 创建玩家对象
        Player player = new Player(avatarId, name, money);

        // 绑定玩家的视图
        player.bindView(view);
        // 绑定玩家拿到的牌视图
        player.bindPokerView(pokerView);

        // 将玩家对象存到玩家列表中
        players.add(player);
    }

    /**
     * 添加玩家
     * @param avatarFilePath 玩家头像文件路径
     * @param name     玩家名称
     * @param money    玩家金额
     * @param view     玩家视图
     */
    public void addPlayer(String avatarFilePath, String name, int money, View view, CardModel pokerView) {
        // 创建玩家对象
        Player player = new Player(avatarFilePath, name, money);

        // 绑定玩家的视图
        player.bindView(view);
        // 绑定玩家拿到的牌视图
        player.bindPokerView(pokerView);

        // 将玩家对象存到玩家列表中
        players.add(player);
    }

    public int deductTableMonet(int tableMoney) {
        for (Player player : players) {
            // 从玩家总金额中减去当前桌默认下注金额
            player.deductTableMonet(tableMoney);
        }
        // 根据当前玩家个数，返回下注的总金额
        return players.size() * tableMoney;
    }

    /**
     * 获取下一个玩家
     *
     * @return 下一个玩家
     */
    public Player nextPlayer() {
        // 玩家索引值
        this.playerIndex++;
        // 判断当前玩家索引值与玩家列表索引值
        if (this.playerIndex >= this.players.size()) {
            // 发牌结束，重置玩家索引
            this.playerIndex = -1;
            return null;
        }

        // 如果当前玩家索引值不大于玩家列表索引值就返回当前玩家
        return this.players.get(this.playerIndex);
    }

    public void showPlayer() {
        for (Player player : players) {
            Log.i("ltxxxx", player.toString());
        }
    }

    /**
     * 切换下一个玩家进行操作
     */
    public void changeOrder() {
        // 获取下一个玩家索引
        playerIndex = (playerIndex + 1) % players.size();
        // 如果当前是重置后的第一次操作
        /*if (playerIndex == -1) {
            playerIndex = 0;  // 保证从第一个玩家开始
        } else {
            playerIndex = (playerIndex + 1) % players.size();
        }*/

        // 找到下一个玩家
        Player player = players.get(playerIndex);
        // 修改玩家的状态
        player.changePlayerState(Player.PlayerState.ACTIVE);

        // 判断上一个玩家是否为null，如果上一个玩家为空，表示该玩家为开始位置
        if (lastActivityPlayer != null) {
            lastActivityPlayer.changePlayerState(Player.PlayerState.IDLE);
//            lastActivityPlayer.cancelAvatarAnimation();
        }

        // 玩家切换后，当前
        lastActivityPlayer = player;
    }

    /**
     * 获取当前活跃的玩家数
     *
     * @return 返回活跃的玩家数
     */
    private int currentActivePlayerCount() {
        int count = 0;
        for (Player player : players) {
            if (!player.isGiveUp()) {
                count++;
            }
        }
        return count;
    }

    /**
     * 给赢的玩家添加金币
     *
     * @param totalMoney 底注总金额
     */
    public void awardWinner(int totalMoney) {
        // 遍历游戏玩家
        for (Player player : players) {
            // 判断玩家是否为活跃状态，内部判断的是是否为弃牌状态
            if (player.isActive()) {
                // 只有一个玩家时就给该玩家加金币
                player.addMoney(totalMoney);
            }
            // 游戏结束后，将桌面的牌全部朝上
            player.showPoker();
        }
    }

    /**
     * 弃牌操作
     */
    public void giveUp() {
        // 获取当前玩家对象
        Player player = players.get(playerIndex);
        // 给当前玩家设置弃牌状态
        player.changePlayerState(Player.PlayerState.GIVE_UP);
        // 获取当前玩家活跃的人数
        int activePlayerCount = currentActivePlayerCount();

        // 监听是否为空
        if (mListener != null) {
            // 将监听的活跃状态人数回调给游戏中心
            mListener.activePlayerChanged(activePlayerCount);
        }
    }

    /**
     * 监听活跃玩家修改状态
     *
     * @param listener
     */
    public void setOnActivePlayerChangeListener(OnActivePlayerChangeListener listener) {
        this.mListener = listener;
    }

    /**
     * 重置玩家信息
     */
    public void resetPlayer() {
        playerIndex = -1;
        lastActivityPlayer = null;  // 新增：清除上次活跃玩家
        for (Player player : players) {
//            Log.i("ltxx", player.getState()+"");
            // 修改玩家状态
            player.changePlayerState(Player.PlayerState.IDLE);
            // 重置玩家牌的状态
            player.resetPokerState();
        }
    }

    /**
     * 加注
     *
     * @param count 加注金额
     */
    public int betting(int count) {
        // 获取到当前玩家
        Player player = players.get(playerIndex);
        // 返回减去的金额值
        return player.deductTableMonet(count);
    }

    /**
     * 玩家pk操作
     * @param bet pk需要扣除的金币数
     * @return 返回扣除的金币数
     */
    public int pk(int bet) {
        // 得到当前玩家
        Player player = players.get(playerIndex);
        // 扣除当前玩家的金币，返回扣除的金币数
        int i = player.deductTableMonet(bet);

        // 找到下一个玩家，返回玩家对象
        Player nextPlayer = findNextActivePlayer();

        // 当前玩家与下一个玩家进行pk（玩家手中的牌pk），返回pk结果
        int result = player.pk(nextPlayer);

        // 判断结果
        if (result > 0) {
            // 当前玩家获胜，将下一个玩家的状态设置为弃牌状态
            nextPlayer.changePlayerState(Player.PlayerState.GIVE_UP);
        } else {
            // 拿到下一个玩家索引值
            playerIndex = players.indexOf(nextPlayer);
            // 下一个玩家获胜，当前玩家设置为弃牌状态
            player.changePlayerState(Player.PlayerState.GIVE_UP);
            // 将下一个玩家设置为活跃状态
            nextPlayer.changePlayerState(Player.PlayerState.ACTIVE);
        }

        // 判断监听者是否为空
        if (pkFinishedListener != null) {
            // 不为空执行方法
            pkFinishedListener.pkFinished();
        }
        // 返回扣除的金币数
        return i;
    }

    /**
     * 寻找下一个玩家对象
     * @return 返回下一个玩家对象
     */
    public Player findNextActivePlayer() {
        // 得到下一个玩家索引值取模
        int i = (playerIndex + 1) % players.size();
        // 使用while遍历所有玩家
        while (true) {
            // 得到玩家对象
            Player nextPlayer = players.get(i);
            // 判断该玩家是否为弃牌状态
            if (!nextPlayer.isGiveUp()) {
                // 若不是弃牌状态就返回该玩家对象
                return nextPlayer;
            }
        }
    }

    public interface OnActivePlayerChangeListener {
        void activePlayerChanged(int count);
    }

    public void setOnPkFinishedListener(OnPkFinishedListener listener) {
        pkFinishedListener = listener;
    }

    public interface OnPkFinishedListener {
        void pkFinished();
    }
}
